home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / games / larn12s.arc / LARN.ARC / NAP.C < prev    next >
C/C++ Source or Header  |  1987-10-28  |  3KB  |  169 lines
  1. /* nap.c         Larn is copyrighted 1986 by Noah Morgan. */
  2. #ifdef GEMDOS
  3. # include <time.h>
  4. #else
  5. # include <signal.h>
  6. # include <sys/types.h>
  7. # ifdef SYSV
  8. #  ifndef MSDOS
  9. #    include <sys/times.h>
  10. #  endif
  11. # else
  12. #  ifdef BSD
  13. #   include <sys/timeb.h>
  14. #  endif BSD
  15. # endif SYSV
  16. #endif GEMDOS
  17.  
  18. /*
  19.  *    routine to take a nap for n milliseconds
  20.  */
  21. nap(x)
  22.     register int x;
  23.     {
  24.     if (x<=0) return; /* eliminate chance for infinite loop */
  25.     lflush();
  26.     if (x > 999) sleep(x/1000); else napms(x);
  27.     }
  28.  
  29. #ifdef NONAP
  30. napms(x)    /* do nothing */
  31.     int x;
  32.     {
  33.     }
  34. #else NONAP
  35. #ifdef SYSV
  36. /*    napms - sleep for time milliseconds - uses times() */
  37. /* this assumes that times returns a relative time in 60ths of a second */
  38. /* this will do horrible things if your times() returns seconds! */
  39.  
  40. # ifdef MSDOS
  41. #   include <dos.h>
  42. unsigned long
  43. dosgetms()
  44. {
  45.     union REGS regs;
  46.  
  47.     regs.h.ah = 0x2C;
  48.     intdos(®s, ®s);
  49.     return (((regs.h.ch * 24L) + regs.h.cl * 60L) +
  50.            regs.h.dh * 60L) + regs.h.dl;
  51.  
  52. }
  53.  
  54. napms(time)
  55. int time;
  56. {
  57.     unsigned long matchclock;
  58.  
  59.     if (time <= 0)
  60.         time = 1;    /* eliminate chance of infinite loop */
  61.     matchclock = dosgetms() + (time + 5) / 10;
  62.     if (matchclock > 8640000)    /* total 100ths-of-seconds in 24 hrs */
  63.         return;
  64.  
  65.     while (matchclock > dosgetms())
  66.         ;
  67. }
  68.  
  69. # else
  70. #  ifdef GEMDOS
  71. napms(time)
  72. int time;
  73. {
  74.     clock_t matchclock, clock();
  75.  
  76.     if (time <= 0)
  77.         time = 1;
  78.     matchclock = clock() + (time / CLK_TCK);
  79.     while(matchclock > clock())
  80.         ;
  81. }
  82. #  else
  83. napms(time)
  84.     int time;
  85.     {
  86.     long matchclock, times();
  87.     struct tms stats;
  88.  
  89.     if (time<=0) time=1; /* eliminate chance for infinite loop */
  90.     if ((matchclock = times(&stats)) == -1 || matchclock == 0)
  91.         return;    /* error, or BSD style times() */
  92.     matchclock += (time / 17);        /*17 ms/tic is 1000 ms/sec / 60 tics/sec */
  93.  
  94.     while(matchclock < times(&stats))
  95.         ;
  96.     }
  97. #  endif GEMDOS
  98. # endif /* MSDOS */
  99.  
  100. #else not SYSV
  101. #ifdef BSD
  102. #ifdef SIGVTALRM
  103. /* This must be BSD 4.2!  */
  104. #include <sys/time.h>
  105. #define bit(_a) (1<<((_a)-1))
  106.  
  107. static  nullf()
  108.     {
  109.     }
  110.  
  111. /*    napms - sleep for time milliseconds - uses setitimer() */
  112. napms(time)
  113.     int time;
  114.     {
  115.     struct itimerval    timeout;
  116.     int     (*oldhandler) ();
  117.     int     oldsig;
  118.  
  119.     if (time <= 0) return;
  120.  
  121.     timerclear(&timeout.it_interval);
  122.     timeout.it_value.tv_sec = time / 1000;
  123.     timeout.it_value.tv_usec = (time % 1000) * 1000;
  124.  
  125.     oldsig = sigblock(bit(SIGALRM));
  126.     setitimer(ITIMER_REAL, &timeout, (struct itimerval *)0);
  127.     oldhandler = signal(SIGALRM, nullf);
  128.     sigpause(oldsig);
  129.     signal(SIGALRM, oldhandler);
  130.     sigsetmask(oldsig);
  131.     }
  132.  
  133. #else
  134. /*    napms - sleep for time milliseconds - uses ftime() */
  135.  
  136. static napms(time)
  137.     int time;
  138.     {
  139.     /* assumed to be BSD UNIX */
  140.     struct timeb _gtime;
  141.     time_t matchtime;
  142.     unsigned short matchmilli;
  143.     register struct timeb *tp = & _gtime;
  144.  
  145.     if (time <= 0) return;
  146.     ftime(tp);
  147.     matchmilli = tp->millitm + time;
  148.     matchtime  = tp->time;
  149.     while (matchmilli >= 1000)
  150.         {
  151.         ++matchtime;
  152.         matchmilli -= 1000;
  153.         }
  154.  
  155.     while(1)
  156.         {
  157.         ftime(tp);
  158.         if ((tp->time > matchtime) ||
  159.             ((tp->time == matchtime) && (tp->millitm >= matchmilli)))
  160.             break;
  161.         }
  162.     }
  163. #endif
  164. #else not BSD
  165. static napms(time) int time; {}    /* do nothing, forget it */
  166. #endif BSD
  167. #endif SYSV
  168. #endif NONAP
  169.